// 音乐播放器控制模块
(function() {
    // 全局变量
    var globalAudio = null;
    var currentMusicData = null;
    var isInitialized = false;
    var playList = []; // 播放列表
    var currentIndex = -1; // 当前播放索引
    
    // 初始化音乐播放器
    function initMusicPlayer() {
        if (isInitialized) return;
        
        // 创建全局音频元素
        if (!document.getElementById('global-audio')) {
            var audioElement = document.createElement('audio');
            audioElement.id = 'global-audio';
            audioElement.preload = 'metadata';
            document.body.appendChild(audioElement);
        }
        
        globalAudio = document.getElementById('global-audio');
        
        // 创建悬浮音乐控制器
        if (!document.getElementById('music-float-btn')) {
            createMusicControllerUI();
        }
        
        // 初始化事件
        initMusicControllerEvents();
        
        isInitialized = true;
    }
    
    // 创建音乐控制器UI
    function createMusicControllerUI() {
        // 创建样式
        var style = document.createElement('style');
        style.textContent = `
            /* 悬浮音乐控制器样式 */
            .music-float-controller {
                position: fixed;
                right: 30px;
                bottom: 30px;
                width: 60px;
                height: 60px;
                background: rgba(30, 159, 255, 0.9);
                border-radius: 50%;
                box-shadow: 0 2px 12px rgba(30, 159, 255, 0.4);
                cursor: pointer;
                display: none;
                align-items: center;
                justify-content: center;
                z-index: 9999;
                transition: all 0.3s ease;
            }
            
            .music-float-controller:hover {
                transform: scale(1.1);
                background: rgba(30, 159, 255, 1);
            }
            
            .music-float-controller.show {
                display: flex;
            }
            
            .music-float-controller i {
                color: white;
                font-size: 24px;
            }
            
            /* 音乐控制面板样式 */
            .music-control-panel {
                position: fixed;
                right: 30px;
                bottom: 100px;
                width: 280px;
                background: white;
                border-radius: 8px;
                box-shadow: 0 2px 12px rgba(0, 0, 0, 0.15);
                padding: 15px;
                display: none;
                z-index: 9998;
            }
            
            .music-control-panel.show {
                display: block;
            }
            
            .music-info {
                text-align: center;
                margin-bottom: 10px;
            }
            
            .music-name {
                font-size: 16px;
                font-weight: bold;
                white-space: nowrap;
                overflow: hidden;
                text-overflow: ellipsis;
            }
            
            .music-singer {
                font-size: 14px;
                color: #666;
            }
            
            .music-controls {
                display: flex;
                justify-content: space-around;
                align-items: center;
            }
            
            .music-controls button {
                background: none;
                border: none;
                cursor: pointer;
                font-size: 20px;
                color: #333;
                transition: color 0.3s;
            }
            
            .music-controls button:hover {
                color: #1E9FFF;
            }
            
            .progress-container {
                margin: 10px 0;
                position: relative;
            }
            
            .progress-bar {
                width: 100%;
                height: 4px;
                background: #e0e0e0;
                border-radius: 2px;
                overflow: hidden;
            }
            
            .progress-fill {
                height: 100%;
                background: #1E9FFF;
                width: 0;
            }
            
            .time-display {
                display: flex;
                justify-content: space-between;
                font-size: 12px;
                color: #999;
            }
        `;
        document.head.appendChild(style);
        
        // 创建悬浮按钮
        var floatBtn = document.createElement('div');
        floatBtn.className = 'music-float-controller';
        floatBtn.id = 'music-float-btn';
        floatBtn.innerHTML = '<i class="layui-icon layui-icon-play" id="float-play-icon"></i>';
        document.body.appendChild(floatBtn);
        
        // 创建控制面板
        var controlPanel = document.createElement('div');
        controlPanel.className = 'music-control-panel';
        controlPanel.id = 'music-panel';
        controlPanel.innerHTML = `
            <div class="music-info">
                <div class="music-name" id="current-music-name"></div>
                <div class="music-singer" id="current-music-singer"></div>
            </div>
            <div class="progress-container">
                <div class="progress-bar">
                    <div class="progress-fill" id="progress-fill"></div>
                </div>
                <div class="time-display">
                    <span id="current-time">00:00</span>
                    <span id="total-time">00:00</span>
                </div>
            </div>
            <div class="music-controls">
                <button id="prev-btn"><i class="layui-icon layui-icon-left"></i></button>
                <button id="play-pause-btn"><i class="layui-icon layui-icon-play"></i></button>
                <button id="next-btn"><i class="layui-icon layui-icon-right"></i></button>
                <button id="close-btn"><i class="layui-icon layui-icon-close"></i></button>
            </div>
        `;
        document.body.appendChild(controlPanel);
    }
    
    // 更新全局音频元素和控制界面
    function updateGlobalAudio(musicData) {
        if (!globalAudio) initMusicPlayer();
        
        currentMusicData = musicData;
        
        // 更新全局音频
        globalAudio.src = musicData.url;
        
        // 使用Promise确保播放成功后更新界面
        globalAudio.play().then(() => {
            // 显示悬浮控制器
            document.getElementById('music-float-btn').classList.add('show');
            
            // 更新控制面板信息
            document.getElementById('current-music-name').textContent = musicData.name;
            document.getElementById('current-music-singer').textContent = musicData.singer;
            
            // 更新图标状态
            updatePlayButtonState();
            
            // 延迟调用表格按钮更新，确保列表中的播放按钮也同步更新
            setTimeout(() => {
                updateTablePlayButtons();
            }, 50);
        }).catch(error => {
            console.error('播放新音乐失败:', error);
            // 即使播放失败也更新界面
            document.getElementById('music-float-btn').classList.add('show');
            document.getElementById('current-music-name').textContent = musicData.name;
            document.getElementById('current-music-singer').textContent = musicData.singer;
            updatePlayButtonState();
        });
    }
    
    // 播放上一曲
    function playPrevious() {
        if (playList.length === 0) return;
        
        // 检查是否已经到了播放列表的第一首歌
        if (currentIndex === 0) {
            // 尝试从当前页面表格获取分页信息
            const tableElem = document.getElementById('musiclist');
            if (tableElem && window.layui && window.layui.table) {
                const table = window.layui.table;
                
                // 获取当前页码信息
                const currentPageElem = document.querySelector('.layui-laypage-em');
                let currentPage = 1;
                if (currentPageElem && currentPageElem.parentNode) {
                    currentPage = parseInt(currentPageElem.parentNode.getAttribute('data-page')) || 1;
                }
                
                // 如果当前不是第一页，尝试加载上一页
                if (currentPage > 1) {
                    // 显示加载提示
                    const layer = window.layui.layer;
                    const loadingIndex = layer.msg('加载上一页音乐...', {icon: 16, time: 0});
                    
                    // 发起请求获取上一页数据
                    const $ = window.layui.jquery;
                    $.get('/music/list', {page: currentPage - 1, limit: 5}, function(resp) {
                        layer.close(loadingIndex);
                        
                        if (resp.code === 0 && resp.data && resp.data.length > 0) {
                            // 转换为播放器需要的格式
                            const prevPageList = resp.data.map(item => ({
                                name: item.name,
                                singer: item.singer,
                                url: item.url || item.path
                            }));
                            
                            // 将上一页数据添加到播放列表前面
                            playList = prevPageList.concat(playList);
                            currentIndex = prevPageList.length - 1; // 上一页的最后一首歌
                            
                            // 更新表格缓存，这样UI也能看到数据
                            if (Array.isArray(table.cache['musiclist'])) {
                                table.cache['musiclist'] = prevPageList.concat(table.cache['musiclist']);
                            }
                            
                            // 播放上一页的最后一首歌
                            updateGlobalAudio(playList[currentIndex]);
                            return;
                        } else {
                            // 如果没有上一页数据，循环播放当前列表的最后一首歌
                            currentIndex = playList.length - 1;
                            updateGlobalAudio(playList[currentIndex]);
                        }
                    });
                    
                    return; // 等待异步加载完成
                }
            }
            
            // 如果是第一页且没有更多数据，则循环播放最后一首歌
            currentIndex = playList.length - 1;
        } else {
            // 正常情况，播放前一首歌
            currentIndex--;
        }
        
        updateGlobalAudio(playList[currentIndex]);
    }
    
    // 播放下一曲
    function playNext() {
        if (playList.length === 0) return;
        
        // 检查是否已经到了播放列表的最后一首歌
        if (currentIndex === playList.length - 1) {
            // 尝试从当前页面表格获取分页信息
            const tableElem = document.getElementById('musiclist');
            if (tableElem && window.layui && window.layui.table) {
                const table = window.layui.table;
                
                // 获取当前页码信息
                const currentPageElem = document.querySelector('.layui-laypage-em');
                let currentPage = 1;
                if (currentPageElem && currentPageElem.parentNode) {
                    currentPage = parseInt(currentPageElem.parentNode.getAttribute('data-page')) || 1;
                }
                
                // 显示加载提示
                const layer = window.layui.layer;
                const loadingIndex = layer.msg('加载下一页音乐...', {icon: 16, time: 0});
                
                // 发起请求获取下一页数据
                const $ = window.layui.jquery;
                $.get('/music/list', {page: currentPage + 1, limit: 5}, function(resp) {
                    layer.close(loadingIndex);
                    
                    if (resp.code === 0 && resp.data && resp.data.length > 0) {
                        // 转换为播放器需要的格式
                        const nextPageList = resp.data.map(item => ({
                            name: item.name,
                            singer: item.singer,
                            url: item.url || item.path
                        }));
                        
                        // 将下一页数据添加到播放列表后面
                        playList = playList.concat(nextPageList);
                        currentIndex = playList.length - nextPageList.length; // 下一页的第一首歌
                        
                        // 更新表格缓存，这样UI也能看到数据
                        if (Array.isArray(table.cache['musiclist'])) {
                            table.cache['musiclist'] = table.cache['musiclist'].concat(nextPageList);
                        }
                        
                        // 播放下一页的第一首歌
                        updateGlobalAudio(playList[currentIndex]);
                        return;
                    } else {
                        // 如果没有下一页数据，循环播放当前列表的第一首歌
                        currentIndex = 0;
                        updateGlobalAudio(playList[currentIndex]);
                    }
                });
                
                return; // 等待异步加载完成
            }
            
            // 如果没有更多数据，则循环播放第一首歌
            currentIndex = 0;
        } else {
            // 正常情况，播放下一首歌
            currentIndex++;
        }
        
        updateGlobalAudio(playList[currentIndex]);
    }
    
    // 设置播放列表
    function setPlayList(musicList) {
        playList = musicList || [];
        // 如果当前没有音乐播放，且播放列表不为空，则播放第一首
        if (!currentMusicData && playList.length > 0) {
            currentIndex = 0;
            updateGlobalAudio(playList[0]);
        } else if (currentMusicData) {
            // 尝试在新列表中找到当前播放的音乐
            const index = playList.findIndex(item => item.url === currentMusicData.url);
            if (index !== -1) {
                currentIndex = index;
            }
        }
    }
    
    // 更新播放按钮状态
    function updatePlayButtonState() {
        const floatIcon = document.getElementById('float-play-icon');
        const playPauseIcon = document.getElementById('play-pause-btn').querySelector('i');
        
        if (globalAudio.paused) {
            floatIcon.className = 'layui-icon layui-icon-play';
            playPauseIcon.className = 'layui-icon layui-icon-play';
        } else {
            floatIcon.className = 'layui-icon layui-icon-pause';
            playPauseIcon.className = 'layui-icon layui-icon-pause';
        }
        
        // 更新表格中的所有播放图标
        updateTablePlayButtons();
    }
    
    // 更新表格中的播放图标状态
    function updateTablePlayButtons() {
        if (!currentMusicData) return;
        
        // 获取当前播放音乐的文件名作为匹配标识
        const currentFileName = currentMusicData.url ? currentMusicData.url.split('/').pop() : '';
        
        // 重置所有播放按钮为播放状态，然后为正在播放的音乐按钮设置暂停状态
        document.querySelectorAll('.preview-btn').forEach(btn => {
            // 重置为播放状态
            btn.setAttribute('data-playing', '0');
            btn.querySelector('i').className = 'layui-icon layui-icon-play';
            
            // 如果有data-src属性，使用URL匹配
            if (!globalAudio.paused && currentFileName) {
                const btnSrc = btn.getAttribute('data-src');
                if (btnSrc) {
                    const btnFileName = btnSrc.split('/').pop();
                    if (btnFileName === currentFileName) {
                        btn.setAttribute('data-playing', '1');
                        btn.querySelector('i').className = 'layui-icon layui-icon-pause';
                    }
                }
                // 对于没有data-src的按钮，我们可以尝试通过按钮所在行的数据来匹配
                // 这种情况主要发生在歌单详情页面
                else {
                    // 查找按钮所在的行，获取音乐信息
                    const row = btn.closest('tr');
                    if (row) {
                        // 尝试从行中提取音乐名称（不同页面可能有不同的结构）
                        const musicNameElement = row.querySelector('td[data-field="musicName"]') || 
                                                row.querySelector('td[data-field="name"]');
                        if (musicNameElement && musicNameElement.textContent) {
                            // 如果音乐名称匹配，设置为暂停状态
                            if (musicNameElement.textContent.trim() === currentMusicData.name) {
                                btn.setAttribute('data-playing', '1');
                                btn.querySelector('i').className = 'layui-icon layui-icon-pause';
                            }
                        }
                    }
                }
            }
        });
    }
    
    // 初始化音乐控制器事件
    function initMusicControllerEvents() {
        // 悬浮按钮点击事件
        document.getElementById('music-float-btn').addEventListener('click', function() {
            const panel = document.getElementById('music-panel');
            panel.classList.toggle('show');
        });
        
        // 播放/暂停按钮事件
        document.getElementById('play-pause-btn').addEventListener('click', togglePlayPause);
        document.getElementById('music-float-btn').addEventListener('dblclick', togglePlayPause);
        
        // 上一曲按钮事件
        document.getElementById('prev-btn').addEventListener('click', playPrevious);
        
        // 下一曲按钮事件
        document.getElementById('next-btn').addEventListener('click', playNext);
        
        // 关闭按钮事件
        document.getElementById('close-btn').addEventListener('click', function() {
            globalAudio.pause();
            globalAudio.src = '';
            currentMusicData = null;
            document.getElementById('music-float-btn').classList.remove('show');
            document.getElementById('music-panel').classList.remove('show');
        });
        
        // 全局音频时间更新事件
        globalAudio.addEventListener('timeupdate', function() {
            const progressFill = document.getElementById('progress-fill');
            const currentTime = document.getElementById('current-time');
            const totalTime = document.getElementById('total-time');
            
            if (globalAudio.duration) {
                const progress = (globalAudio.currentTime / globalAudio.duration) * 100;
                progressFill.style.width = progress + '%';
                currentTime.textContent = formatAudioTime(globalAudio.currentTime);
                totalTime.textContent = formatAudioTime(globalAudio.duration);
            }
        });
        
        // 全局音频播放事件
        globalAudio.addEventListener('play', updatePlayButtonState);
        
        // 全局音频暂停事件
        globalAudio.addEventListener('pause', updatePlayButtonState);
        
        // 全局音频结束事件
        globalAudio.addEventListener('ended', function() {
            updatePlayButtonState();
            // 播放结束后自动播放下一首
            playNext();
        });
        
        // 点击其他区域关闭面板
        document.addEventListener('click', function(e) {
            const panel = document.getElementById('music-panel');
            const floatBtn = document.getElementById('music-float-btn');
            
            if (panel.classList.contains('show') && 
                !panel.contains(e.target) && 
                !floatBtn.contains(e.target)) {
                panel.classList.remove('show');
            }
        });
    }
    
    // 切换播放/暂停状态
    function togglePlayPause() {
        if (globalAudio.paused) {
            globalAudio.play().then(() => {
                // 播放成功后立即更新所有按钮状态
                updatePlayButtonState();
                // 立即调用表格按钮更新，确保列表中的播放按钮也同步更新
                setTimeout(() => {
                    updateTablePlayButtons();
                }, 50);
            }).catch(error => {
                console.error('播放失败:', error);
                // 即使播放失败也尝试更新按钮状态
                updatePlayButtonState();
            });
        } else {
            globalAudio.pause();
            // 暂停后立即更新所有按钮状态
            updatePlayButtonState();
            // 立即调用表格按钮更新，确保列表中的播放按钮也同步更新
            setTimeout(() => {
                updateTablePlayButtons();
            }, 50);
        }
    }
    
    // 格式化音频时间
    function formatAudioTime(timeInSeconds) {
        if (isNaN(timeInSeconds)) return '00:00';
        let minutes = Math.floor(timeInSeconds / 60);
        let seconds = Math.floor(timeInSeconds % 60);
        return (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds < 10 ? '0' + seconds : seconds);
    }
    
    // 适配弹窗中的音频元素
    function adaptModalAudio(modalElement) {
        if (!globalAudio) initMusicPlayer();
        
        var audioElement = modalElement.querySelector('audio.shiting');
        if (audioElement) {
            // 监听弹窗中的音频播放事件，同步到全局音频
            audioElement.addEventListener('play', function() {
                // 获取音频源信息
                const audioSrc = this.src;
                const currentTime = this.currentTime;
                
                // 如果全局音频未设置或源不同，则更新全局音频
                if (!globalAudio.src || globalAudio.src !== audioSrc) {
                    // 从URL中提取文件名作为音乐名称
                    const urlParts = audioSrc.split('/');
                    const fileName = urlParts[urlParts.length - 1];
                    const musicName = fileName.split('.')[0];
                    
                    // 更新全局音频并播放
                    updateGlobalAudio({
                        name: musicName,
                        singer: '未知歌手',
                        url: audioSrc
                    });
                } else if (globalAudio.paused) {
                    // 如果是同一首歌且已暂停，则继续播放
                    globalAudio.currentTime = currentTime;
                    globalAudio.play();
                }
            });
            
            // 监听弹窗中的音频暂停事件，同步到全局音频
            audioElement.addEventListener('pause', function() {
                if (!globalAudio.paused) {
                    globalAudio.pause();
                }
            });
            
            // 如果全局有正在播放的音频，同步到弹窗
            if (!globalAudio.paused && currentMusicData && audioElement.src === globalAudio.src) {
                audioElement.currentTime = globalAudio.currentTime;
            }
        }
    }
    
    // 暴露方法到window对象
    window.MusicPlayer = {
        init: initMusicPlayer,
        play: function(musicData, musicList) {
            // 如果提供了播放列表，更新播放列表
            if (musicList) {
                setPlayList(musicList);
                // 找到当前音乐在列表中的索引
                currentIndex = musicList.findIndex(item => item.url === musicData.url);
                if (currentIndex === -1) {
                    // 如果不在列表中，添加到列表末尾
                    musicList.push(musicData);
                    currentIndex = musicList.length - 1;
                }
            } else if (!playList.some(item => item.url === musicData.url)) {
                // 如果没有提供列表，但当前音乐不在播放列表中，则添加到列表
                playList.push(musicData);
                currentIndex = playList.length - 1;
            } else {
                // 如果当前音乐在播放列表中，更新索引
                currentIndex = playList.findIndex(item => item.url === musicData.url);
            }
            
            updateGlobalAudio(musicData);
            
            // 强制更新表格中的播放按钮状态
            setTimeout(updateTablePlayButtons, 100);
        },
        adaptModalAudio: adaptModalAudio,
        togglePlayPause: togglePlayPause,
        playPrevious: playPrevious,
        playNext: playNext,
        setPlayList: setPlayList,
        getCurrentMusic: function() { return currentMusicData; },
        updateTableButtons: updateTablePlayButtons, // 暴露方法供外部调用
        getAudioElement: function() { return globalAudio; }
    };
    
    // 自动初始化（非登录页面）
    if (window.location.pathname.indexOf('login') === -1) {
        // 等待页面加载完成后初始化
        if (document.readyState === 'loading') {
            document.addEventListener('DOMContentLoaded', initMusicPlayer);
        } else {
            initMusicPlayer();
        }
    }
})();